package cn.iocoder.yudao.module.system.service.user;

import cn.iocoder.yudao.framework.common.exception.ErrorCode;
import cn.iocoder.yudao.module.system.controller.admin.user.vo.user.UserAssetsPageReqVO;
import cn.iocoder.yudao.module.system.controller.admin.user.vo.user.UserAssetsSaveReqVO;
import cn.iocoder.yudao.module.system.dal.dataobject.user.AdminUserDO;
import cn.iocoder.yudao.module.system.dal.dataobject.user.UserAssetsDO;
import cn.iocoder.yudao.module.system.dal.mysql.user.AdminUserMapper;
import cn.iocoder.yudao.module.system.dal.mysql.user.UserAssetsMapper;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

import java.time.LocalDateTime;
import java.util.*;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;


import javax.annotation.Resource;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;

/**
 * 用户资源 Service 实现类
 *
 * @author 芋道源码
 */
@Service
@Validated
public class UserAssetsServiceImpl implements UserAssetsService {

    @Resource
    private UserAssetsMapper userAssetsMapper;

    @Resource
    AdminUserMapper adminUserMapper;

    @Override
    public Integer createUserAssets(UserAssetsSaveReqVO createReqVO) {
        // 插入
        UserAssetsDO userAssets = BeanUtils.toBean(createReqVO, UserAssetsDO.class);
        userAssetsMapper.insert(userAssets);
        // 返回
        return userAssets.getId();
    }

    @Override
    public void updateUserAssets(UserAssetsSaveReqVO updateReqVO) {
        // 校验存在
        validateUserAssetsExists(updateReqVO.getId());
        // 更新
        UserAssetsDO updateObj = BeanUtils.toBean(updateReqVO, UserAssetsDO.class);
        userAssetsMapper.updateById(updateObj);
    }

    @Override
    public void deleteUserAssets(Integer id) {
        // 校验存在
        validateUserAssetsExists(id);
        // 删除
        userAssetsMapper.deleteById(id);
    }

    private void validateUserAssetsExists(Integer id) {
        if (userAssetsMapper.selectById(id) == null) {
            throw exception(new ErrorCode(404,"用户资源不存在"));
        }
    }

    @Override
    public UserAssetsDO getUserAssets(Integer id) {
        return userAssetsMapper.selectById(id);
    }

    @Override
    public PageResult<UserAssetsDO> getUserAssetsPage(UserAssetsPageReqVO pageReqVO) {
        return userAssetsMapper.selectPage(pageReqVO);
    }

    @Override
    public UserAssetsDO getUserAssetsByUserId(Long userId) {
        UserAssetsDO userAssetsDO = null;
        List<UserAssetsDO> userAssetsDOList = userAssetsMapper.selectList(UserAssetsDO::getUserId, userId);
        if (userAssetsDOList != null&& !userAssetsDOList.isEmpty()) {
            userAssetsDO = userAssetsDOList.get(0);
        }


        if (userAssetsDO == null) {
            // 用户资产信息不存在，创建新的用户资产记录
            UserAssetsSaveReqVO createReqVO = new UserAssetsSaveReqVO();
            createReqVO.setUserId(userId);

            // 初始化所有字段为默认值
            createReqVO.setTrailCount(0);
            createReqVO.setTrailLeftCount(0);
            createReqVO.setPsCount(0);
            createReqVO.setPsLeftCount(0);
            createReqVO.setContentCount(0);
            createReqVO.setContentLeftCount(0);
            createReqVO.setAskCount(0);
            createReqVO.setAskLeftCount(0);

            // 时间字段初始化为null（表示未开通相关服务）
            createReqVO.setTrailUpdateTime(null);
            createReqVO.setPsUpdateTime(null);
            createReqVO.setContentStartTime(null);
            createReqVO.setContentEndTime(null);
            createReqVO.setSimulationStartTime(null);
            createReqVO.setSimulationEndTime(null);

            // 创建用户资产记录
            Integer assetId = createUserAssets(createReqVO);

            // 重新查询创建的记录
            userAssetsDO = userAssetsMapper.selectById(assetId);
        }

        if (userAssetsDO != null) {
            //部分资源还存在user表中
            AdminUserDO adminUserDO = adminUserMapper.selectOne("id", userId);
            if (adminUserDO != null) {
                userAssetsDO.setTrailCount(adminUserDO.getTestTotalTimes());
                userAssetsDO.setTrailLeftCount(adminUserDO.getTestLeftTimes());
                userAssetsDO.setPsCount(adminUserDO.getProTotalTimes());
                userAssetsDO.setPsLeftCount(adminUserDO.getProLeftTimes());
            }
        }

        return userAssetsDO;
    }

    @Override
    public boolean validateUserContentMembership(Long userId) {

        return true;
//        if (userId == null) {
//            return true; // 如果没有用户ID，则不进行检查，直接通过
//        }
//
//        // 获取用户资产信息
//        UserAssetsDO userAssets = getUserAssetsByUserId(userId);
//
//        // 检查用户是否有内容会员权限
//        if (userAssets == null) {
//            // 用户资产信息不存在，抛出异常
//            throw exception(new ErrorCode(403, "用户未开通内容会员服务"));
//        }
//
//        // 检查是否有内容会员有效期
//        boolean hasValidMembership = userAssets.getContentEndTime() != null &&
//                                    userAssets.getContentEndTime().isAfter(LocalDateTime.now());
//
//        // 如果是有效会员，则不扣减次数，直接通过
//        if (hasValidMembership) {
//            return true;
//        }
//
//        // 如果不是有效会员，则检查剩余次数
//        if (userAssets.getContentLeftCount() == null || userAssets.getContentLeftCount() <= 0) {
//            // 剩余次数不足，抛出异常
//            throw exception(new ErrorCode(403, "内容查看次数不足，请充值"));
//        }
//
//        // 扣减剩余次数
//        userAssets.setContentLeftCount(userAssets.getContentLeftCount() - 1);
//        // 更新用户资产信息
//        UserAssetsSaveReqVO updateReqVO = new UserAssetsSaveReqVO();
//        updateReqVO.setId(userAssets.getId());
//        updateReqVO.setContentLeftCount(userAssets.getContentLeftCount());
//        updateUserAssets(updateReqVO);
//
//        return true;
    }

    @Override
    public boolean validateAskMembership(Long userId) {
        if (userId == null) {
            return true; // 如果没有用户ID，则不进行检查，直接通过
        }

        // 获取用户资产信息
        UserAssetsDO userAssets = getUserAssetsByUserId(userId);

        // 检查用户是否有问答会员权限
        if (userAssets == null) {
            // 用户资产信息不存在，抛出异常
            throw exception(new ErrorCode(403, "用户未开通问答会员服务"));
        }

        // 检查剩余次数
        if (userAssets.getAskLeftCount() == null || userAssets.getAskLeftCount() <= 0) {
            // 剩余次数不足，抛出异常
            throw exception(new ErrorCode(403, "问答次数不足，请充值"));
        }

        // 扣减剩余次数
        userAssets.setAskLeftCount(userAssets.getAskLeftCount() - 1);
        // 更新用户资产信息
        UserAssetsSaveReqVO updateReqVO = new UserAssetsSaveReqVO();
        updateReqVO.setId(userAssets.getId());
        updateReqVO.setAskLeftCount(userAssets.getAskLeftCount());
        updateUserAssets(updateReqVO);

        return true;
    }

    @Override
    public boolean validateSimulationVipMembership(Long userId) {
        if (userId == null) {
            return true; // 如果没有用户ID，则不进行检查，直接通过
        }

        // 获取用户资产信息
//        UserAssetsDO userAssets = getUserAssetsByUserId(userId);
//
//        // 检查用户是否有模拟志愿VIP权限
//        if (userAssets == null) {
//            // 用户资产信息不存在，抛出异常
//            throw exception(new ErrorCode(403, "用户未开通模拟志愿VIP服务"));
//        }
//
//        // 检查是否有模拟志愿VIP有效期
//        boolean hasValidVip = userAssets.getSimulationEndTime() != null &&
//                             userAssets.getSimulationEndTime().isAfter(LocalDateTime.now());
//
//        if (!hasValidVip) {
//            // VIP已过期或未开通，抛出异常
//            throw exception(new ErrorCode(403, "模拟志愿VIP已过期或未开通，请充值"));
//        }

        return true;
    }

    @Override
    public boolean grantSimulationVip(Long userId, Integer days) {
        if (userId == null || days == null || days <= 0) {
            throw exception(new ErrorCode(400, "参数错误：用户ID和天数不能为空，且天数必须大于0"));
        }

        // 检查用户是否可以领取VIP（只有首次领取才允许）
        if (!canClaimSimulationVip(userId)) {
            throw exception(new ErrorCode(400, "用户已有模拟志愿VIP记录，不能重复领取"));
        }

        // 获取用户资产信息
        UserAssetsDO userAssets = getUserAssetsByUserId(userId);

        LocalDateTime now = LocalDateTime.now();

        if (userAssets == null) {
            // 用户资产信息不存在，创建新的用户资产记录
            UserAssetsSaveReqVO createReqVO = new UserAssetsSaveReqVO();
            createReqVO.setUserId(userId);
            createReqVO.setSimulationStartTime(now);
            createReqVO.setSimulationEndTime(now.plusDays(days));
            // 同时设置内容会员
            createReqVO.setContentStartTime(now);
            createReqVO.setContentEndTime(now.plusDays(days));

            // 初始化其他字段为默认值
            createReqVO.setTrailCount(0);
            createReqVO.setTrailLeftCount(0);
            createReqVO.setPsCount(0);
            createReqVO.setPsLeftCount(0);
            createReqVO.setContentCount(9999);
            createReqVO.setContentLeftCount(9999);
            createReqVO.setAskCount(0);
            createReqVO.setAskLeftCount(0);

            createUserAssets(createReqVO);
        } else {
            // 用户资产信息存在，但没有VIP记录，直接设置VIP时间
            UserAssetsSaveReqVO updateReqVO = new UserAssetsSaveReqVO();
            updateReqVO.setId(userAssets.getId());
            updateReqVO.setUserId(userId);
            updateReqVO.setSimulationStartTime(now);
            updateReqVO.setSimulationEndTime(now.plusDays(days));
            // 同时设置内容会员
            updateReqVO.setContentStartTime(now);
            updateReqVO.setContentEndTime(now.plusDays(days));

            // 保持其他字段不变
            updateReqVO.setTrailCount(userAssets.getTrailCount());
            updateReqVO.setTrailLeftCount(userAssets.getTrailLeftCount());
            updateReqVO.setPsCount(userAssets.getPsCount());
            updateReqVO.setPsLeftCount(userAssets.getPsLeftCount());
            updateReqVO.setContentCount(userAssets.getContentCount() + 9999);
            updateReqVO.setContentLeftCount(userAssets.getContentLeftCount() + 9999);
            updateReqVO.setAskCount(userAssets.getAskCount());
            updateReqVO.setAskLeftCount(userAssets.getAskLeftCount());
            updateReqVO.setTrailUpdateTime(userAssets.getTrailUpdateTime());
            updateReqVO.setPsUpdateTime(userAssets.getPsUpdateTime());

            updateUserAssets(updateReqVO);
        }

        return true;
    }

    @Override
    public boolean canClaimSimulationVip(Long userId) {
        if (userId == null) {
            return false;
        }

        // 获取用户资产信息
        UserAssetsDO userAssets = getUserAssetsByUserId(userId);

        // 如果用户资产信息不存在，说明从未有过任何VIP记录，可以领取
        if (userAssets == null) {
            return true;
        }

        // 如果模拟志愿VIP的开始时间和结束时间都为null，说明从未开通过，可以领取
        if (userAssets.getSimulationStartTime() == null && userAssets.getSimulationEndTime() == null) {
            return true;
        }

        // 如果有任何模拟志愿VIP记录（无论是否过期），都不能再领取
        return false;
    }
}